/**
 * Proyecto: Cognitum
 * Global IT Services 2008
 * @author mislas
 */
Cognitum.Polizas.Endoso.Componentes.Generales = Ext.extend(Karma.FB2, {

    initComponent: function() {

        if (LOG.isDebugEnabled()) {
            LOG.debug('[Endoso.Editor] Ramo clave: ' + this.ramoClave + ', es pool: ' + this.esPool);
        }
        Ext.apply(this, {
            title: 'Datos generales',
            column1items: [{
                    fieldLabel: 'Folio',
                    allowBlank: true,
                    disabled: true,
                    name: 'Folio'
                }, {
                    fieldLabel: 'OT',
                    allowBlank: true,
                    name: 'Id',
                    disabled: true
                }, {
                    fieldLabel: 'Descripcion',
                    name: 'Descripcion',
                    allowBlank: true
                }, {
                    xtype: 'datefield',
                    name: 'FechaEnvio',
                    fieldLabel: 'Fecha Envio'
                }, {
                    xtype: 'datefield',
                    name: 'FechaEmision',
                    fieldLabel: 'Fecha Emision'
                }, {
                    xtype: 'enum.combo',
                    enumName: 'Cognitum.Dominio.Polizas.EstatusEndoso',
                    fieldLabel: 'Estatus',
                    disabled: true,
                    name: 'EstatusEndoso'
                }, {
                    xtype: 'entity.link',
                    entityName: 'TipoEndoso',
                    fieldLabel: 'Tipo de Endoso',
                    name: 'Tipo',
                    disabled: true
                }, {
                    xtype: 'entity.link',
                    entityName: 'TipoMovimiento',
                    fieldLabel: 'Tipo de Movimiento',
                    name: 'TipoMovimiento',
                    contextTriggers: [
                        {
                            id: 'Tipo',
                            query: 'a.TipoEndoso.Id=?'
                        }
                    ]
                }, {
                    xtype: 'entity.link',
                    fieldLabel: 'Poliza',
                    entityName: 'Polizas',
                    name: 'Poliza',
                    additionalProperties: ['Impuesto', 'RecargosPct', 'ComisionPct'],
                    listeners: {
                        set: {
                            fn: function() {
                                var polizaFld = this.getForm().findField('Poliza');
                                var poliza = polizaFld.getEntityValue();
                                var vigFin = this.getForm().findField('VigenciaFin');
                                vigFin.setValue(poliza.VigenciaFin);
                                var impuesto = this.getForm().findField('Impuesto');
                                var recargoPct = this.getForm().findField('RecargosPct');
                                var comisionPct = this.getForm().findField('ComisionPct');
                                if (!Ext.isEmpty(poliza)) {
                                    impuesto.setValue(poliza.Impuesto);
                                    recargoPct.setValue(poliza.RecargosPct);
                                    comisionPct.setValue(poliza.ComisionPct);
                                }
                            },
                            scope: this
                        }
                    },
                    preContext: [
                        {
                            value: this.ramoClave,
                            query: "p.Ramo.DivisionOperativa = " + this.ramoClave
                        },
                        {
                            value: this.esPool,
                            query: 'p.SubRamo.Flotilla = ' + this.esPool
                        }
                    ],
                    additionalProperties: ['Impuesto']
                }, {
                    xtype: 'datefield',
                    name: 'VigenciaInicio',
                    fieldLabel: 'Vigencia Inicio'
                }, {
                    xtype: 'datefield',
                    name: 'VigenciaFin',
                    fieldLabel: 'Vigencia Fin'
                }
            ],
            column2items: [{
                    fieldLabel: 'Prima',
                    name: 'Prima',
                    xtype: 'numberfield',
                    listeners: {
                        'keyup': {
                            fn: this.onKeyup2,
                            scope: this
                        }
                    },
                    enableKeyEvents: true,
                    subtotal: true
                }, {
                    fieldLabel: 'Gastos',
                    name: 'Gastos',
                    xtype: 'numberfield',
                    listeners: {
                        'keyup': {
                            fn: this.onKeyup2,
                            scope: this
                        }
                    },
                    enableKeyEvents: true,
                    subtotal: true
                }, {
                    fieldLabel: 'Recargos Porcentaje',
                    name: 'RecargosPct',
                    xtype: 'numberfield',
                    listeners: {
                        'keyup': {
                            fn: this.onKeyup2,
                            scope: this
                        }
                    },
                    enableKeyEvents: true
                }, {
                    fieldLabel: 'Recargos Importe',
                    name: 'RecargosImporte',
                    xtype: 'numberfield',
                    listeners: {
                        'keyup': {
                            fn: this.onKeyup2,
                            scope: this
                        }
                    },
                    enableKeyEvents: true
                }, {
                    fieldLabel: 'Comision Porcentaje',
                    name: 'ComisionPct',
                    xtype: 'numberfield',
                    listeners: {
                        'keyup': {
                            fn: this.onKeyup2,
                            scope: this
                        }
                    },
                    enableKeyEvents: true
                }, {
                    fieldLabel: 'Comision Importe',
                    name: 'ComisionImporte',
                    xtype: 'numberfield',
                    listeners: {
                        'keyup': {
                            fn: this.onKeyup2,
                            scope: this
                        }
                    },
                    enableKeyEvents: true
                }, {
                    fieldLabel: 'Neto',
                    name: 'Neto',
                    xtype: 'numberfield',
                    readOnly: true,
                    neto: true
                }, {
                    fieldLabel: 'Impuesto %',
                    name: 'Impuesto',
                    entityName: 'Impuestos',
                    xtype: 'entity.link',
                    listeners: {
                        'set': {
                            fn: this.calculaMonto,
                            scope: this
                        }
                    },
                    additionalProperties: ['Porcentaje']
                    //,
                    //disabled: true
                }, {
                    fieldLabel: 'Total',
                    name: 'Total',
                    xtype: 'numberfield',
                    total: true,
                    readOnly: true
                }, {
	                fieldLabel: 'Mesa de Control',
	                name: 'EstatusMesaDeControl',
	                xtype: 'enum.combo',
	                enumName: 'Cognitum.Dominio.MesaControl.StatusMesaControl',
	                readonly: true,
	                disabled: true
	            }
            ]
        });
        Cognitum.Polizas.Endoso.Componentes.Generales.superclass.initComponent.apply(this, arguments);
    },

    onKeyup2: function(field, e) {
        this.calculaMonto(field);
    },

    calculaMonto: function(field) {
        var Poliza = this.getForm().findField('Poliza');
        if (Ext.isEmpty(Poliza.getEntityValue())) {
            return;
        }
        var sumatoria = 0;
        var Total = this.getForm().findField('Total');
        var Neto = this.getForm().findField('Neto');
        var ComPorct = this.getForm().findField('ComisionPct');
        var ComImport = this.getForm().findField('ComisionImporte');
        var RecPorct = this.getForm().findField('RecargosPct');
        var RecImport = this.getForm().findField('RecargosImporte');
        var ImpuestoValue = Poliza.getEntityValue().Impuesto.Porcentaje;
        var Derechos = this.getForm().findField('Gastos');
        var Prima = this.getForm().findField('Prima');

        //ComImport.setValue((parseFloat(ComPorct.getValue()) / 100) * parseFloat(Prima.getValue()));

        if (!Ext.isEmpty(field) && field.getName() == 'ComisionImporte') {
            var valor = (parseFloat(ComImport.getValue()) * 100) / parseFloat(Prima.getValue());
            if (valor == 'NaN') {
                ComPorct.setValue('');
            }
            else {
                ComPorct.setValue(valor);
            }
        }
        else {
            var valor = ((parseFloat(ComPorct.getValue()) / 100) * parseFloat(Prima.getValue()));
            if (valor == 'NaN') {
                ComImport.setValue('');
            }
            else {
                ComImport.setValue(valor);
            }
        }

        if (!Ext.isEmpty(field) && field.getName() == 'RecargosImporte') {
            var valor = (parseFloat(RecImport.getValue()) * 100) / parseFloat(Prima.getValue());
            if (valor == 'NaN') {
                RecPorct.setValue('');
            }
            else {
                RecPorct.setValue(valor);
            }
        }
        else {
            var valor = ((parseFloat(RecPorct.getValue()) / 100) * parseFloat(Prima.getValue()));
            if (valor == 'NaN') {
                RecImport.setValue('');
            }
            else {
                RecImport.setValue(valor);
            }
        }

        sumatoria = parseFloat(Derechos.getValue()) + parseFloat(RecImport.getValue());
        Neto.setValue(parseFloat(Prima.getValue()) + sumatoria);

        ImpuestoValue = parseFloat(Neto.getValue()) * (parseFloat(ImpuestoValue) / 100);
        Total.setValue(parseFloat(Neto.getValue()) + ImpuestoValue);
    },

    updateControls: function(value) {
        if (Ext.isEmpty(value)) {
            return;
        }
        if (value.EstatusEndoso >= 1) {
            this.disable();
        }
        if (!this.isNew) {
            this.getForm().findField('TipoMovimiento').disable();
            this.getForm().findField('Poliza').disable();
            this.calculaMonto();
        } else {
            if (value.Poliza != null) {
                this.getForm().findField('Poliza').disable();
            }
        }
    }

});
Ext.reg('end.ctls.gral', Cognitum.Polizas.Endoso.Componentes.Generales);

Cognitum.Polizas.Endoso.Editor = Ext.extend(Karma.EBCard, {

    ramoClave: null,

    esPool: 0,

    initComponent: function() {
        var _sections = [
            {
                xtype: 'end.ctls.gral',
                ramoClave: this.ramoClave,
                esPool: this.esPool,
                title: 'General'
            },
            {
                title: 'Instrucciones Aseguradora',
                items: [
                    {
                        xtype: 'htmleditor',
                        name: 'InstruccionesAseguradora',
                        hideLabel: true,
                        anchor: '99% 99%'
                    }
                ]
            },
            {
                title: 'Bitacora',
                items: [
                    {
                        fieldLabel: 'Bitacoras',
                        hideLabel: true,
                        name: 'Bitacoras',
                        entityName: 'BitacorasTramite',
                        xtype: 'ag.list',
                        context: 'b.Tramite.Id=?',
                        anchor: '99% 99%'
                    }
                ]
            },
            {
                title: 'Recibos',
                items: [
                    {
                        hideLabel: true,
                        name: 'Recibos',
                        entityName: 'Recibos',
                        xtype: 'ag.list',
                        context: 'r.Tramite.Id=?',
                        anchor: '99% 99%',
                        updateControls: function(value) {
                            if (Ext.isEmpty(value)) {
                                return;
                            }
                            // menu config
                            this.canUpdate = this.canUpdate && value.EstatusEndoso == 1;
                            this.deleteMenuAction.setDisabled(!(this.canDelete && value.EstatusEndoso == 1));
                            this.newMenuAction.setDisabled(!(this.canNew && value.EstatusEndoso == 1));
                            this.newToolbarButton.setDisabled(!(this.canNew && value.EstatusEndoso == 1));
                        }
                    }
                ]
            },
            {
                xtype: 'sec.editor',
                title: 'Seguridad'
            },
            {
                xtype: 'aud.editor',
                title: 'Auditoria'
            }
        ];

        if (this.seccionesAdicionales) {
            Ext.each(this.seccionesAdicionales, function(item) {
                _sections.push(item);
            }, this);
        }
        Ext.apply(this, {
            sections: _sections
        });
        Cognitum.Polizas.Endoso.Editor.superclass.initComponent.apply(this, arguments);
    },

    getTBarCustomControls: function() {
        return [this.descartarBtn = new Ext.Button({
            xtype: 'button',
            formBind: true,
            text: 'Descartar',
            handler: this.onDescartar,
            scope: this
        }), this.cancelarBtn = new Ext.Button({
            xtype: 'button',
            formBind: true,
            text: 'Cancelar',
            handler: this.onCancelar,
            scope: this
        }), this.mesaDeControlMenu = new Ext.Button({
			text: 'Mesa de Control',
            hidden: true,
			menu: {
				items: [
	                this.mesaCtlEnviarBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Enviar Mesa de Control',
	                    handler: this.onEnviarMesaControl,
	                    scope: this
	                }), this.mesaCtlOTMarcaErroresBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Marcar OT con Errores',
	                    handler: this.onMarcarOTConErrores,
	                    scope: this
	                })
	                , this.mesaCtlCorrectoBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Marcar Correcto',
	                    handler: this.onMarcarCorrecto,
	                    scope: this
	                }), this.mesaCtlConErroresBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Marcar con Errores',
	                    handler: this.onMarcarConErrores,
	                    scope: this
	                }), this.mesaCtlIncorrectoBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Rechazar Errores',
	                    handler: this.onRechazarConErrores,
	                    scope: this
	                }), this.mesaCtlCorrectoErroresBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Aceptar con Errores',
	                    handler: this.onAceptarConErrores,
	                    scope: this
	                }), this.mesaCtlSolicitarCorreccionBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Solicitar correcciones',
	                    handler: this.onSolicitarCorrecion,
	                    scope: this
	                })
	            ]
			}
        })];
    },

    puedeEnviarMesaControl: function(value) {
        if (!this.entity.security.has('EnviarMesaControl')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && (value.EstatusMesaDeControl === 14);
    },

    puedeMarcarCorrecto: function(value) {
        if (!this.entity.security.has('MarcarCorrecto')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && (value.EstatusMesaDeControl === 1);
    },

    puedeMarcarConErrores: function(value) {
        if (!this.entity.security.has('MarcarConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && (value.EstatusMesaDeControl === 1);
    },

    puedeRechazarConErrores: function(value) {
        if (!this.entity.security.has('RechazarConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && (value.EstatusMesaDeControl === 3);
    },
    
    puedeMarcarOTConErrores: function(value) {
        if (!this.entity.security.has('MarcarOTConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && (value.EstatusMesaDeControl === 1);
    },    

    puedeAceptarConErrores: function(value) {
        if (!this.entity.security.has('AceptarConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && (value.EstatusMesaDeControl === 3);
    },

    puedeSolicitarCorreccion: function(value) {
        if (!this.entity.security.has('SolicitarCorreccion')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusEndoso === 0) && 
		(value.EstatusMesaDeControl === 4 || value.EstatusMesaDeControl === 5);
    },

    onEnviarMesaControl: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onEnviarMesaControl] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por enviar a mesa de control, el tramite ya no podra ser modificado, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoEnviarMesaControl', otId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onEnviarMesaControl] ->');
        }
    },

    onMarcarCorrecto: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onMarcarCorrecto] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como recibida correctamente, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoMarcarCorrecto', otId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onMarcarCorrecto] ->');
        }
    },

    onMarcarConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onMarcarConErrores] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como con errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result, text){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoMarcarConErrores', [otId, text], {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onMarcarConErrores] ->');
        }
    },
    
    onMarcarOTConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onMarcarOTConErrores] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como con errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result, text) {
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoMarcarEndosoOTErrores', [otId, text], {
                        fn: function(ot) {
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onMarcarConErrores] ->');
        }
    },

    onRechazarConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onRechazarConErrores] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como rechazada por contener errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoRechazaErrores', otId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onRechazarConErrores] ->');
        }
    },

    onAceptarConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onAceptarConErrores] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como aceptada pero con errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoAceptaConErrores', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onAceptarConErrores] ->');
        }
    },

    onSolicitarCorrecion: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onSolicitarCorrecion] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por solicitar la correccion de los errores encontrados, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                    this.doOperationWithParams('DoSolicitaCorreccion', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onSolicitarCorrecion] ->');
        }
    },

    updateControls: function(value) {
        Cognitum.Polizas.Endoso.Editor.superclass.updateControls.apply(this, arguments);
        this.guardarBtn.setDisabled(!this.puedeGuardar(value));
        this.descartarBtn.setDisabled(!this.puedeDescartar(value));
        this.cancelarBtn.setDisabled(!this.puedeCancelar(value));
        
		if (value.TipoMovimiento == null || value.TipoMovimiento.Descripcion != 'Cancelacion interna') {
	        if (!this.isNew && value.EstatusEndoso === 0) {
	            this.mesaDeControlMenu.show();
	            
	            this.mesaCtlEnviarBtn.setDisabled(!this.puedeEnviarMesaControl(value));
	            this.mesaCtlConErroresBtn.setDisabled(!this.puedeMarcarConErrores(value));
	            this.mesaCtlOTMarcaErroresBtn.setDisabled(!this.puedeMarcarOTConErrores(value));
	            this.mesaCtlCorrectoBtn.setDisabled(!this.puedeMarcarCorrecto(value));
	            this.mesaCtlIncorrectoBtn.setDisabled(!this.puedeRechazarConErrores(value));
	            this.mesaCtlCorrectoErroresBtn.setDisabled(!this.puedeAceptarConErrores(value));
	            this.mesaCtlSolicitarCorreccionBtn.setDisabled(!this.puedeSolicitarCorreccion(value));
	        } else {
	            this.mesaDeControlMenu.hide();
	        }
		} else {
            this.mesaDeControlMenu.hide();
        }
    },

    puedeGuardar: function(value) {
        if (this.isNew) {
            return this.entity.security.New;
        }
        return (value.EstatusEndoso == 0 && 
			(value.EstatusMesaDeControl === 14 || value.EstatusMesaDeControl === 3)) 
			&& this.entity.security.Update;
    },

    puedeDescartar: function(value) {
        if (!this.entity.security.has('Descartar')) {
            return false;
        }
        return (!this.isNew) && value.EstatusEndoso == 0 &&
               (value.EstatusMesaDeControl === 5 || value.EstatusMesaDeControl === 6);
    },

    puedeCancelar: function(value) {
        if (!this.entity.security.has('Cancelar')) {
            return false;
        }
        return (!this.isNew && value.EstatusEndoso == 0 && 
			(value.EstatusMesaDeControl === 14 || value.EstatusMesaDeControl === 6));
    },

    onDescartar: function() {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[EditorEndoso.onDescartar] -');
        }
        Ext.Msg.show({
            title: 'Descarte',
            msg: 'Esta apunto de realizar un descarte',
            buttons: Ext.Msg.YESNO,
            fn: function(result) {
                if (result === 'yes') {
                    var desForm = null;
                    if (this.getForm().findField('Tipo').getEntityValue().Nombre != 'B') {
                        desForm = new Cognitum.Polizas.Endoso.DescartarEndosoForm({
                            endoso: this.value,
                            listeners: {
                                'descartar': {
                                    fn: function(folio, generaRecibos, pNetaRecibo1, gastosRecibo1, numRecibos) {
                                        var endoso = this.getForm().findField('Id').getValue();
                                        var parametros = new Array();
                                        parametros.push(endoso);
                                        parametros.push(folio);
                                        var tipo = this.getForm().findField('Tipo').getEntityValue().Nombre;
                                        if (tipo == 'A') {
                                            parametros.push(generaRecibos);
                                            parametros.push(pNetaRecibo1);
                                            parametros.push(gastosRecibo1);
                                            parametros.push(numRecibos);
                                        }
                                        if (tipo == 'B') {

                                        }
                                        if (tipo == 'D') {
                                            parametros.push(generaRecibos);
                                            parametros.push(pNetaRecibo1);
                                            parametros.push(gastosRecibo1);
                                        }
                                        this.status.showBusy();
                                        var service = this.entity.service;
                                        this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                                        this.doOperationWithParams('DoDescartar', parametros, {
                                            fn: function(endoso) {
                                                this.status.setStatus({
                                                    text: 'El endoso fue descartado existosamente. De ser necesario modifique valores y guarde sus cambios.',
                                                    iconCls: 'ok-icon',
                                                    clear: true
                                                });
                                                this.updateControls(endoso);

                                                /*this.getForm().findField('Prima').enable();*/

                                                if (endoso.TipoMovimiento.ModificaPoliza) {
                                                    Ext.Msg.show({
                                                        title: 'Exito',
                                                        msg: 'La operacion de Descarte se realizo con exito.',
                                                        buttons: Ext.Msg.YESNO,
                                                        fn: function(result) {
                                                            if (result === 'yes') {
                                                                var entidad = Karma.Core.ModuleManager.Instance.getEntity('Polizas');
                                                                entidad.Open(endoso.Poliza.Id);
                                                            }
                                                        },
                                                        icon: Ext.MessageBox.QUESTION,
                                                        scope: this
                                                    });
                                                }
                                                else {
                                                    Ext.MessageBox.alert('Exito', 'La operacion de Descarte se realizo con exito.');
                                                }
                                            },
                                            scope: this
                                        });
                                    },
                                    scope: this
                                }
                            }
                        });
                        desForm.show();
                    } else {
                        desForm = new Cognitum.Polizas.Endoso.DescartarEndosoBForm({
                            endoso: this.value,
                            listeners: {
                                'descartarB': {
                                    fn: function(folio, modificaCaratula) {
                                        var endoso = this.getForm().findField('Id').getValue();
                                        var parametros = new Array();
                                        parametros.push(endoso);
                                        parametros.push(folio);
                                        this.status.showBusy();
                                        var service = this.entity.service;
                                        this.entity.service = 'Cognitum.Dominio.Polizas.IEndosoService';
                                        this.doOperationWithParams('DoDescartar', parametros, {
                                            fn: function(endoso) {
                                                this.status.setStatus({
                                                    text: 'El endoso fue descartado existosamente. De ser necesario modifique valores y guarde sus cambios.',
                                                    iconCls: 'ok-icon',
                                                    clear: true
                                                });
                                                this.updateControls(endoso);

                                                if (endoso.TipoMovimiento.ModificaPoliza) {
                                                    Ext.Msg.show({
                                                        title: 'Exito',
                                                        msg: 'La operacion de Descarte se realizo con exito. ¿Desea modificar la póliza?',
                                                        buttons: Ext.Msg.YESNO,
                                                        fn: function(result) {
                                                            if (result === 'yes') {
                                                                var entidad = Karma.Core.ModuleManager.Instance.getEntity('Polizas');
                                                                entidad.Open(endoso.Poliza.Id);
                                                                var editorWin = Karma.WinManager.Instance.getIfExist(this, endoso.Poliza.Id);                                                                
                                                                editorWin.getForm().enable();
                                                            }
                                                        },
                                                        icon: Ext.MessageBox.QUESTION,
                                                        scope: this
                                                    });
                                                }
                                                else {
                                                    Ext.MessageBox.alert('Exito', 'La operacion de Descarte se realizo con exito.');
                                                }
                                            },
                                            scope: this
                                        });
                                    },
                                    scope: this
                                }
                            }
                        });
                        desForm.show();
                    }
                }

            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
    },

    onCancelar: function() {
        Ext.Msg.show({
            title: 'Cancelación',
            msg: 'Esta apunto de realizar una Cancelación',
            buttons: Ext.Msg.YESNO,
            fn: function(result) {
                if (result === 'yes') {
                    var endoso = this.getForm().findField('Id').getValue();
                    this.doOperationWithParams('DoCancela', endoso, {
                        fn: function(endoso) {
                            this.status.setStatus({
                                text: 'El endoso fue cancelado existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(endoso);
                            Ext.MessageBox.alert('Exito', 'La operacion de Cancelacion se realizo con exito.');
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Endoso.onCancelar] ->');
        }
    },

    getTBarDynamicControls: function(value) {
        if (value.Id > 0) {
            var cartaEntity = Karma.Core.ModuleManager.Instance.getEntity('Cartas');
            return [
                {
                    fn: cartaEntity.getMenuEndoso,
                    params: value.Id,
                    scope: cartaEntity
                }
            ];
        }
    }

});

Ext.reg('end.editor', Cognitum.Polizas.Endoso.Editor);
